package other

import (
	"context"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"

	"github.com/gogf/gf/v2/frame/g"
	goopenai "github.com/sashabaranov/go-openai"
)

var Openai = &openai{}

type openai struct {
	ctx context.Context
	cfg goopenai.ClientConfig
}

func (r *openai) Ctx(ctx context.Context) *openai {
	token := g.Config().MustGet(ctx, "openai.secretKey").String()
	cfg := goopenai.DefaultConfig(token)

	// cfg.BaseURL = g.Config().MustGet(ctx, "openai.uri").String()

	proxy := g.Config().MustGet(ctx, "openai.proxy").String()
	proxyUrl, _ := url.Parse(proxy)
	cfg.HTTPClient = &http.Client{
		Transport: &http.Transport{
			Proxy: http.ProxyURL(proxyUrl),
		},
	}

	r.ctx = ctx
	r.cfg = cfg

	return r
}
func (r *openai) Gpt() {
	client := goopenai.NewClientWithConfig(r.cfg)

	req := goopenai.ChatCompletionRequest{
		Model:     goopenai.GPT3Dot5Turbo,
		MaxTokens: 20,
		Messages: []goopenai.ChatCompletionMessage{
			{
				Role:    goopenai.ChatMessageRoleUser,
				Content: "Lorem ipsum",
			},
		},
	}

	resp, err := client.CreateChatCompletion(r.ctx, req)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}

	fmt.Println(resp.Choices[0].Message.Content)
}
func (r *openai) GptStream() {
	client := goopenai.NewClientWithConfig(r.cfg)

	req := goopenai.ChatCompletionRequest{
		Model:     goopenai.GPT3Dot5Turbo,
		Stream:    true,
		MaxTokens: 20,
		Messages: []goopenai.ChatCompletionMessage{
			{
				Role:    goopenai.ChatMessageRoleUser,
				Content: "Lorem ipsum",
			},
		},
	}

	// resp, err := client.CreateChatCompletion(r.ctx, req)
	stream, err := client.CreateChatCompletionStream(r.ctx, req)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	defer stream.Close()

	for {
		resp, err := stream.Recv()
		if errors.Is(err, io.EOF) {
			fmt.Println("\nStream finished")
			return
		}

		if err != nil {
			fmt.Printf("\nStream error: %v\n", err)
			return
		}

		fmt.Println(resp)
		// fmt.Printf(resp.Choices[0].Delta.Content)
	}
	// fmt.Println(resp.Choices[0].Message.Content)
}

// req := openai.CompletionRequest{
// 	Model:     openai.GPT3Ada,
// 	MaxTokens: 5,
// 	Prompt:    "Lorem ipsum",
// Stream:    true,
// }
// resp, err := c.CreateCompletion(ctx, req)
// stream, err := c.CreateCompletionStream(ctx, req)
// if err != nil {
// 	fmt.Printf("Completion error: %v\n", err)
// 	return
// }
//
// fmt.Println(resp.Choices[0].Text)
// defer stream.Close()

// for {
// 	response, err := stream.Recv()
// 	if errors.Is(err, io.EOF) {
// 		fmt.Println("Stream finished")
// 		return
// 	}
//
// 	if err != nil {
// 		fmt.Printf("Stream error: %v\n", err)
// 		return
// 	}
//
// 	fmt.Printf("Stream response: %v\n", response)
// }

// req := openai.AudioRequest{
// 	Model:    openai.Whisper1,
// 	FilePath: "recording.mp3",
// }
//
// resp, err := c.CreateTranscription(ctx, req)
// if err != nil {
// 	fmt.Printf("Transcription error: %v\n", err)
// 	return
// }
//
// fmt.Println(resp.Text)

// reqUrl := openai.ImageRequest{
// 	Prompt:         "Parrot on a skateboard performs a trick, cartoon style, natural light, high detail",
// 	Size:           openai.CreateImageSize256x256,
// 	ResponseFormat: openai.CreateImageResponseFormatURL,
// 	N:              1,
// }
//
// respUrl, err := c.CreateImage(ctx, reqUrl)
// if err != nil {
// 	fmt.Printf("Image creation error: %v\n", err)
// 	return
// }
// fmt.Println(respUrl.Data[0].URL)
//
// // Example image as base64
// reqBase64 := openai.ImageRequest{
// 	Prompt:         "Portrait of a humanoid parrot in a classic costume, high detail, realistic light, unreal engine",
// 	Size:           openai.CreateImageSize256x256,
// 	ResponseFormat: openai.CreateImageResponseFormatB64JSON,
// 	N:              1,
// }
//
// respBase64, err := c.CreateImage(ctx, reqBase64)
// if err != nil {
// 	fmt.Printf("Image creation error: %v\n", err)
// 	return
// }
//
// imgBytes, err := base64.StdEncoding.DecodeString(respBase64.Data[0].B64JSON)
// if err != nil {
// 	fmt.Printf("Base64 decode error: %v\n", err)
// 	return
// }
//
// r := bytes.NewReader(imgBytes)
// imgData, err := png.Decode(r)
// if err != nil {
// 	fmt.Printf("PNG decode error: %v\n", err)
// 	return
// }
//
// file, err := os.Create("example.png")
// if err != nil {
// 	fmt.Printf("File creation error: %v\n", err)
// 	return
// }
// defer file.Close()
//
// if err := png.Encode(file, imgData); err != nil {
// 	fmt.Printf("PNG encode error: %v\n", err)
// 	return
// }
//

// messages := make([]openai.ChatCompletionMessage, 0)
// reader := bufio.NewReader(os.Stdin)
//
// for {
// 	text, _ := reader.ReadString('\n')
// 	text = strings.Replace(text, "\n", "", -1)
// 	messages = append(messages, openai.ChatCompletionMessage{
// 		Role:    openai.ChatMessageRoleUser,
// 		Content: text,
// 	})
//
// 	resp, err := client.CreateChatCompletion(ctx,
// 		openai.ChatCompletionRequest{
// 			Model:    openai.GPT3Dot5Turbo,
// 			Messages: messages,
// 		},
// 	)
//
// 	if err != nil {
// 		fmt.Printf("ChatCompletion error: %v\n", err)
// 		continue
// 	}
//
// 	content := resp.Choices[0].Message.Content
// 	messages = append(messages, openai.ChatCompletionMessage{
// 		Role:    openai.ChatMessageRoleAssistant,
// 		Content: content,
// 	})
// 	fmt.Println(content)
// }
